La version numrique du sujet fournie en fichier texte (format *.txt) doit tre ouverte en tant que braille informatique. Elle sera affiche en braille 6 points. Lapplication  bloc-notes  des ordinateurs courants, ou des logiciels spcialiss, peut tre utilise.  dfaut, reportez-vous  la version en papier. 
Le candidat doit rdiger ses rponses sur un second fichier, et peut demander  un assistant ou  un secrtaire de recopier sa production de faon manuscrite sur une copie.
Un fichier en format *.pdf est galement fourni.
La page du document original est indique par  PO 1  pour  page originale n1 . Les rfrences aux pages braille (sommaire, rfrences en cours de sujet) font rfrence au sujet braille emboss.

po `1
`25-nsij`2me1
braille intgral
baccalaurat gnral
preuve d'enseignement de spcialit
session `2025
numrique et sciences informatiques
preuve du mercredi `18 juin `2025
dure de l'preuve: `3 heures `30
volume `1 -- texte
l'usage de la calculatrice n'est pas autoris.
ds que ce sujet vous est remis, assurez-vous qu'il est complet.
le sujet comporte `15 pages numrotes de `1  `15 dans la version originale.
la version en braille intgral est compose de deux volumes:
9o volume `1: le sujet de `47 pages numrotes de `1  `47
9o volume `2: `5 planches tactiles sur papier thermogonfl et une feuille plastique vierge.
le sujet est compos de trois exercices indpendants.
le candidat traite les trois exercices.
`;le signe de modification mathmatique est omis sur les planches tactiles.'
sommaire
9o exercice `1 `4
partie a `4
partie b `7
partie c `12
9o exercice `2 `19
9o exercice `3 `29
partie a `29
partie b `40
partie c `42
po `2
exercice `1 (`6 points)
cet exercice porte sur les arbres binaires et la programmation python.
le codage de shannon-fano est un systme de codage utilis pour la compression sans pertes de donnes. il a t mis au point par robert fano d'aprs une ide de claude shannon.
partie a
dans cette partie, on va tudier l'utilisation des arbres de codage.
un arbre de codage est un arbre binaire o chaque feuille contient un symbole du texte que l'on souhaite coder. le code binaire d'un symbole s'obtient alors en concatnant les `0 et les `1 sur les branches qui mnent de la racine  la feuille contenant ce symbole. par exemple, pour l'arbre de codage donn en figure `1, le symbole c est cod par le mot binaire `1101, tandis que d est cod par le mot binaire `11000. les codes binaires des symboles ne sont donc pas tous de la m2me taille. pour dcoder un mot binaire, il suffit de descendre dans l'arbre, depuis la racine, selon les `0 et les `1 qu'on lit jusqu' trouver une feuille (et donc un symbole), puis de recommencer avec la suite du mot binaire pour dcoder les symboles suivants.
figure `1. exemple d'arbre de codage
`;voir planche tactile no `1. pour viter toute confusion, la virgule prsente dans une des feuilles est note  la suite de l'indicateur de valeur de base ainsi: ,'
`1. crire le mot binaire qui sera utilis pour encoder le caractre espace, reprsent par le symbole - dans l'arbre.
`2. dterminer le texte cod par le mot binaire `0001110101111110011001.
po `3
`3. citer le type de parcours de l'arbre qui permettrait d'obtenir les symboles classs par taille d'encodage croissante.
partie b
dans cette partie, on va utiliser le codage de shannon-fano pour encoder le texte:
je pense, donc je suis
dans la mthode de shannon-fano, l'arbre de codage est calcul pour un texte donn par l'algorithme suivant.
9o tape `1: classer les symboles du texte par nombre d'occurrences croissant;
9o tape `2: en gardant le classement obtenu, sparer les symboles en deux sous-groupes de sorte que les totaux des nombres d'occurrences soient les plus proches possibles dans les deux sous-groupes;
9o tape `3: placer tous les symboles du premier groupe dans le fils gauche (c4t tiquet par `1), et ceux du second groupe dans le fils droit (c4t tiquet par `0);
9o tape `4: recommencer rcursivement pour chacun des sous-groupes jusqu' ce qu'ils n'aient plus qu'un seul symbole; on a alors une feuille tiquete par ce symbole.
aprs avoir class les symboles par nombre d'occurrences croissant (tape `1), on obtient le tableau suivant:
`;tableau trait en colonnes et en deux parties, (a) et (b), page braille suivante.'
`;abrviations:
s: symbole
no: nombre d'occurrences'
`;le signe numrique est omis dans le tableau suivant.'
(a)
s: i; u; c; o; d; ,
no: 1; 1; 1; 1; 1; 1
(b)
s: p; n; j; s; -; e
no: 1; 2; 2; 3; 4; 4
`4. justifier par le calcul que l'tape `2 mne  la situation illustre par la figure `2.
figure `2. le rsultat de l'tape `2
`;voir planche tactile no `2. la virgule est prcde de l'indicateur de valeur de base ,.'
en appliquant l'algorithme de shannon-fano, on peut obtenir l'arbre de la figure `3.
po `4
figure `3. arbre de codage obtenu par l'algorithme de shannon-fano
`;voir planche tactile no `3.'
on rappelle qu'un arbre rduit  un seul n9ud, c'est--dire rduit  une feuille, est de hauteur `0.
`5. donner la hauteur de l'arbre de la figure `3 et prciser dans le contexte de l'exercice ce qu'elle reprsente.
on rappelle que dans le code ascii, chaque symbole est cod sur un octet.
`6. justifier, en comparant le codage ascii et le codage de shannon-fano, que ce second codage permet d'utiliser environ deux fois moins d'octets pour le texte:
je pense, donc je suis
`7. dessiner, en vous inspirant de l'arbre de la figure `1, un arbre de codage qui permettrait d'encoder le mot "chiffrer" en utilisant l'algorithme de shannon-fano.
`;pour rpondre  cette question, une feuille plastique vierge est propose en fin de volume `2.'
partie c
dans cette partie, on souhaite crire une fonction python qui donnera le mot binaire obtenu pour coder un texte avec l'algorithme de shannon-fano. on commence par la fonction creer-dico-occ:
po `5
`1 def creer-dico-occ(texte):
`2 """renvoie un dictionnaire dont les cls sont les
`3 symboles de texte et les valeurs associes leur
`4 nombre d'occurences dans texte"""
`5 dico `" ()
`6 for symbole in texte:
`7 if symbole in dico:
`8 dico(symbole)b `" ...
`9 else:
`10 dico(symbole)b `" ...
`11 return dico
`8. recopier et complter les lignes `8 et `10 du code de la fonction creer-dico-occ.
on dispose d'une fonction creer-tab-trie qui prend en paramtre un dictionnaire construit avec la fonction creer-dico-occ et qui renvoie une liste de tuples classs dans l'ordre croissant d'occurrences des symboles.
par exemple:
@@@ texte `" 'je pense, donc je suis'
@@@ dico `" creer-dico-occ(texte)
@@@ creer-tab-trie(dico)
(('i', `1), ('u', `1), ('c', `1), ('o', `1), ('d', `1), (',', `1), ('p', `1), ('n', `2), ('j', `2), ('s', `3), (' ', `4), ('e', `4))b
`9. crire une fonction somme-occ qui prend en paramtres un tableau tab de tuples (symbole, nb-occ) et qui renvoie la somme des nombres d'occurrences des symboles du tableau. les tuples utiliss sont de m2me structure que l'lment renvoy dans l'exemple prcdent.
on suppose pour la suite qu'on dispose d'une fonction separe qui spare un tableau tri en deux sous-tableaux de manire  ce que les sommes de ces derniers soient les plus proches possible:
`1 def separe(tab):
`2 moitie `" somme-occ(tab) // `2
`3 somme `" `0
`4 i `" `0
`5 while moitie @ somme:
`6 somme `" somme `! tab(i)b(`1)b
`7 i `" i `! `1
`8 tab`1 `" (tab(k)b for k in range(`0, i))b
`9 tab`2 `" (tab(k)b for k in range(i, len(tab)))b
`10 return tab`1, tab`2
`10. recopier et complter les lignes `9 et `11 du code de la fonction rcursive shannon qui prend en paramtres un caractre symbole et un tableau tri tab et qui renvoie l'criture binaire associe  symbole dans le tableau tab.
po `6
`1 def shannon(symbole, tab):
`2 """renvoie l'criture binaire associe  symbole
`3 dans le tableau tri tab"""
`4 if len(tab) `"" `1:
`5 return ""
`6 else:
`7 t`1, t`2 `" separe(tab)
`8 if symbole in (elt(`0)b for elt in t`1)b:
`9 return "`1" `! ...
`10 else:
`11 return "`0" `! ...
`11. dcrire ce qui garantit la terminaison de la fonction rcursive shannon.
`12. crire une fonction encode-shannon qui prend en paramtre un texte de type str et renvoie un mot binaire de type str obtenu aprs encodage par l'algorithme de shannon-fano.
on pourra utiliser les fonctions vues prcdemment qui sont recenses ci-aprs.
creer-dico-occ(texte)
renvoie un dictionnaire dont les cls sont les symboles du texte et les valeurs associes leur nombre d'occurrences
creer-tab-trie(dico)
renvoie la liste cre  partir d'un dictionnaire de couples (symbole, nb-occ)
separe(tab)
renvoie le tuple compos des `2 sous-tableaux tris avec des sommes d'occurences proches shannon(symbole, tab)
renvoie l'criture binaire associe au symbole dans le tableau tri tab
po `7
exercice `2 (`6 points)
cet exercice porte sur les bases de donnes relationnelles, le langage sql et la programmation.
une ludothque municipale a dcid de moderniser sa gestion en crant une base de donnes informatique. cette base de donnes permettra de suivre les jeux disponibles, les emprunts effectus par les adhrents, ainsi que les avis laisss sur les diffrents jeux. pour commencer, quatre tables principales ont t identifies: jeu, adhrent, emprunt et avis. ces tables et leurs relations vont permettre de stocker toutes les informations essentielles au bon fonctionnement de la ludothque. on va considrer que la ludothque n'a qu'un exemplaire de chaque jeu (deux jeux de la ludothque ne peuvent donc pas avoir le m2me nom).
figure `1. la base de donnes de la ludothque
`;voir planche tactile no `4.'
dans la figure ci-dessus `;(de la planche tactile no `4)', les cls primaires de chacune des tables sont `;mises en vidence pas le symbole ""', et les cls trangres sont prcdes du symbole 0.
po `8
dans cet exercice, on pourra utiliser les clauses du langage sql pour:
9o construire des requ2tes d'interrogation  l'aide de select, from, where (avec les oprateurs logiques and, or) et join ... on;
9o construire des requ2tes d'insertion et de mise  jour  l'aide de update, insert et delete;
9o affiner les recherches  l'aide de distinct et order by;
9o raliser des agrgations  l'aide de count.
par exemple, l'instruction sql:
select count(-nomjeu) from jeu;
donne le nombre de jeux prsents dans la table jeu.
`1. expliquer pourquoi on ne peut pas prendre l'attribut nom comme cl primaire pour la relation adherent.
`2. dcrire ce que donne la requ2te sql suivante:
select nomjeu, editeur
from jeu
order by nomjeu;
lorsqu'un jeu est emprunt et n'a pas encore t rendu, la valeur de l'attribut daterendu de la table emprunt est  null.
`3. crire une requ2te permettant de connaitre le nom de tous les jeux qui sont en cours d'emprunt.
`4. crire une requ2te sql pour afficher le nom et le prnom de tous les adhrents qui ont emprunt le jeu "catan".
`5. claire voyant, adhrente de longue date  cette ludothque, a emprunt le jeu "catan" et l'a rendu le `3 juin `2025. lors de l'emprunt, la valeur de id-emprunt tait `1538. crire une requ2te sql qui a permis de mettre  jour la base de donnes afin qu'elle prenne en compte que ce jeu a t rendu. toutes les dates de la base de donnes sont crites sous le format 'aaaa-mm-jj'.
`6. crire une requ2te sql qui permet de trouver le nom et la catgorie de tous les jeux de la ludothque sortis  partir de `2010 et dont l'1ge minimum est strictement infrieur  `10 ans.
la ludothque dcide d'organiser des vnements. pour cela, elle ajoute une relation evenement  sa base de donnes. en outre, pour chaque vnement, elle souhaite garder en mmoire une trace des adhrents qui y ont particip.  cette fin, elle complte sa base avec une relation participation.
po `9
figure `2. la base de donnes de la ludothque actualise
`;voir planche tactile no `5'
`7. proposer les cls trangres de la table participation en prcisant le nom des attributs auxquels elles font rfrence.
le programme python suivant permet de crer la liste de tous les jeux emprunts, sachant que, dans celle-ci, un jeu va appara3tre autant de fois qu'il a t emprunt.
`1 import sqlite`3
`2
`3 0 connexion  la base de donnes
`4 connection `" sqlite`3.con nect("ludotheque.db")
`5 curseur `" connection.cursor()
`6
`7 0 excution de la requ2te
`8 curseur.execute("select nomjeu from emprunt")
`9
`10 0 rcupration des rsultats
`11 jeux `" curseur.fetchall()
`12
`13 liste `" ()b
`14 0 cration de la liste des jeux emprunts
`15 for jeu in jeux:
`16 liste.append(jeu(`0)b)
`17
`18 0 fermeture de la connexion
po `10
`19 curseur.close()
`20 connection.close()
`8. crire un script python permettant de crer le dictionnaire dict-emprunts qui,  chaque jeu emprunt, associe le nombre de fois o il a t emprunt.
on veut crer un podium des jeux les plus souvent emprunts. comme il peut y avoir des galits  la premire, deuxime ou troisime place, il peut y avoir plus de trois jeux slectionns sur le podium.
par exemple, si le dictionnaire des emprunts est:
`1 dict-emprunts `" (
`2 "terraforming mars": `25,
`3 "codenames": `22,
`4 "agricola": `18,
`5 "puerto rico": `18,
`6 "caylus": `18,
`7 "dominion": `22,
`8 "dixit": `12
`9 )
il y aura sur le podium les jeux "agricola", "puerto rico" et "caylus" puis les jeux "dominion" et "codenames" et enfin
le jeu "terraforming mars".
pour modliser ce podium en python, on va utiliser une liste de trois listes.
pour l'exemple prcdent, cette liste sera:
(("agricola", "puerto rico", "caylus")b,
("dominion", "codenames")b, ("terraforming mars")b)b.
`9. proposer un script python permettant de gnrer ce podium.
exercice `3 (`8 points)
cet exercice porte sur la programmation de base en python, la scurisation des communications et les rseaux.
partie a -- la mthode du masque jetable
dans cette partie, on s'intresse  une mthode de chiffrement dite du masque jetable. voici ce que l'on peut lire sur le site wikipdia:
le chiffrement par la mthode du masque jetable consiste  combiner le message en clair avec une cl prsentant les caractristiques trs particulires suivantes:
9o la cl doit 2tre une suite de caractres au moins aussi longue que le message  chiffrer;
po `11
9o les caractres composant la cl doivent 2tre choisis de faon totalement alatoire;
9o chaque cl, ou "masque", ne doit 2tre utilise qu'une seule fois (d'o le nom de masque jetable).
illustrons cette mthode par un exemple: on souhaite chiffrer le message hello avec la cl alatoire, ou "masque", wmckl.
pour cela, on attribue un nombre  chaque lettre, par exemple le rang dans l'alphabet, de `0  `25.
`;tableaux linariss et transposs en colonnes, pages braille `31 et `32.'
tableau de correspondance
lettre rang
a `0
b `1
c `2
d `3
e `4
f `5
g `6
h `7
i `8
j `9
k `10
l `11
m `12
n `13
o `14
p `15
q `16
r `17
s `18
t `19
u `20
v `21
w `22
x `23
y `24
z `25
ensuite, on additionne la valeur du rang de chaque lettre du message avec la valeur du rang correspondante dans le masque.
enfin, si le rsultat est suprieur  `25 on soustrait `26 (calcul dit "modulo `26").
ainsi, le chiffrement du message hello avec la cl wmckl donne le message chiffr dqnvz comme le montre l'illustration suivante.
figure `1. exemple de chiffrement par la mthode du masque jetable
`;illustration transcrite sous forme d'un tableau linaris'
; `7 (h); `4 (e); `11 (l); `11 (l); `14 (o); message;
`!: `22 (w); `12 (m); `2 (c); `10 (k); `11 (l); masque
`"; `29; `16; `13; `21; `25; masque `! message;
`"; `3 (d); `16 (q); `13 (n); `21 (v); `25 (z); masque `! message modulo `26
source: d'aprs l'article masque jetable de wikipdia en franais (https://fr.wikipedia.org/wiki/masque-jetable)
dans cet exercice, on ne travaillera que sur des cha3nes de caractres crites en majuscules non accentues (les `26 caractres allant de 'a'  'z').
`1. chiffrer, par la mthode du masque jetable, le message libre  l'aide de la cl eyqmt.
po `12
en python, on cre une fois pour toute la variable alphabet qui sera accessible et utilisable dans toutes les fonctions. celle-ci contient la liste des `26 lettres de l'alphabet ranges dans l'ordre alphabtique:
alphabet `" :('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z')b
`2. crire une fonction python indice qui prend pour paramtre une liste l et renvoie l'indice de element dans la liste l.
on supposera que chaque lment de la liste l n'y appara3t qu'une seule fois et que element est bien prsent dans la liste l.
par exemple, l'appel indice(alphabet, 'k') renvoie l'entier `10.
`3. crire une fonction python lettres-vers-indices qui prend pour paramtre une cha3ne de caractres et renvoie, dans l'ordre, la liste des indices de ces caractres dans l'alphabet.
par exemple, l'appel lettre s-vers-indices('hello') renvoie la liste d'entiers (`7, `4, `11, `11, `14)b.
on dispose galement d'une fonction indices-vers-lettres, qu'on ne demande pas d'crire, permettant de convertir une liste d'entiers, compris entre `0 et `25, en une cha3ne de caractres.
par exemple, l'appel indices-vers-lettres((`3, `16, `13, `21, `25)b) renvoie la cha3ne de caractres 'dqnvz'.
ci-aprs, on donne une fonction python chiffrement incomplte, qui,  partir d'un message msg et d'une cl cle entrs en paramtres, renvoie la cha3ne de caractres reprsentant le message chiffr par la mthode du masque jetable.
`1 def chiffrement(msg, cle):
`2 assert len(cle) @`" len(msg), 'impossible'
`3 indices-msg `" lettres-vers-indices(msg)
`4 indices-cle `" lettres-vers-indices(cle)
`5 n `" len(msg)
`6 indices-msg-chiffre `" ()b
`7 for k in range(n):
`8 ind `" ...
`9 if ind @`" `26:
`10 ind `" ...
`11 indices-msg-chiffre.append(i nd)
`12 msg-chiffre `" indices-vers-lettres(...)
`13 return msg-chiffre
`4. recopier et complter les lignes `7  `13 de la fonction chiffrement.
po `13
`5. indiquer, en justifiant, ce que l'on observe lors de l'appel chiffrement('reseau', 'gftz').
on s'intresse maintenant au dchiffrement d'un message chiffr par la mthode du masque jetable.
par exemple, le dchiffrement du message dqnvz avec la cl wmckl donne le message hello.
`6. dchiffrer le message gmedh avec la cl fveit.
`7. expliquer comment procder pour dchiffrer un message lorsqu'on conna3t la cl.
on souhaite maintenant crire, en python, une fonction dechiffrement qui permet de dchiffrer un message chiffr par la mthode du masque jetable.
pour cela, on s'inspire de la fonction chiffrement dans laquelle les paramtres ainsi que les lignes `2  `5 sont inchanges. on dcide cependant de remplacer, ligne `6, le nom de la variable indices-msg-chiffre par le nom plus explicite indices-msg-dechiffre.
`8. adapter les lignes `6  `13 de la fonction chiffrement pour obtenir la nouvelle fonction dechiffrement.
partie b -- scurisation des communications
`9. expliquer la diffrence entre un algorithme de chiffrement symtrique et un algorithme de chiffrement asymtrique.
alice souhaite envoyer un message  bob par l'intermdiaire d'un rseau informatique en utilisant un algorithme de chiffrement asymtrique.
pour cela, bob envoie  alice sa cl publique. alice chiffre ensuite le message  l'aide de la cl publique de bob qu'elle vient de recevoir, puis elle envoie ce message chiffr  bob.
`10. indiquer comment bob peut dchiffrer le message que lui envoie alice.
`11. expliquer comment une tierce personne pourrait se faire passer pour alice sans que bob ne s'en aperoive.
`12. expliquer brivement le fonctionnement du protocole https.
`13. expliquer pourquoi, pour scuriser intgralement les communications sur internet, on utilise le protocole https plut4t qu'un chiffrement asymtrique.
partie c -- rseaux
bob et marc travaillent pour une petite compagnie d'assurances.
po `14
leurs postes de travail font partie d'un m2me rseau local gr par l'administratrice systme qui dispose du bloc d'adresses ipv`4 `192.168.110.0/24.
la notation /`24 situ  la suite de l'adresse `192.168.110.0 signifie que le masque de sous-rseau du rseau de cette entreprise est `255.255.255.0: les trois premiers octets d'une adresse ip sur ce rseau permettent donc d'identifier la partie rseau de l'adresse, alors que le dernier octet permet d'identifier la partie h4te et est propre  chaque machine sur le rseau. ce sous-rseau permet donc d'attribuer `256 adresses ipv`4 diffrentes.
l'administratrice choisit alors d'attribuer, en reprsentation dcimale, l'identifiant `115 pour la partie h4te du poste de travail de bob et l'identifiant `153 pour celui de marc.
depuis son poste de travail, marc souhaite tester la communication avec celui de bob. pour cela, il excute la commande ping `192.168.100.115 et obtient l'affichage suivant:
--- `192.168.100.115 ping statistics ---
`4 packets transmitted, `0 received, `100 packet loss, time `3060 ms
`14. expliquer l'affichage obtenu et corriger l'erreur de marc.
afin d'amliorer les performances et la scurit du rseau de l'entreprise, l'administratrice systme dcide de sparer le rseau local en plusieurs sous-rseaux et de les relier entre eux par des routeurs. pour cela, elle modifie le masque de sous-rseau qui devient `11111111.11111111.111 11111.11100000, donn ici en reprsentation binaire.
`15. donner la reprsentation dcimale de ce masque de sous-rseau.
pour obtenir l'adresse ipv`4 du sous-rseau auquel appartient une machine, il suffit d'appliquer l'oprateur binaire et, bit  bit, entre le masque de sous-rseau et l'adresse ipv`4 de la machine.
par exemple, prenons le dernier octet de l'adresse ipv`4 de bob dont la reprsentation binaire est `01110011: en appliquant bit  bit l'oprateur binaire et entre cet octet et l'octet correspondant dans le masque, on obtient le dernier octet de l'adresse du sous-rseau, soit `01100000.
`;le signe de modification mathmatique est omis dans le code suivant.'
1 1 1 0 0 0 0 0 (224)
et 0 1 1 1 0 0 1 1 (115)
--------------------
0 1 1 0 0 0 0 0 (96)
le poste de travail de bob est donc sur le sous-rseau d'adresse `192.168.110.96.
po `15
`16. indiquer le nombre total d'adresses ipv`4 pouvant 2tre attribues sur le sous-rseau d'adresse `192.168.110.96 sur lequel se trouve bob.
l'administratrice systme attribue maintenant l'adresse ipv`4 `192.168.110.134 au poste de travail de zo, nouvelle employe de la compagnie d'assurances.
`17. donner la reprsentation binaire du nombre `134.
depuis son poste de travail, zo excute les deux commandes suivantes:
9o commande no `1:
ping `192.168.110.115;
9o commande no `2:
ping `192.168.110.153.
`18. indiquer, en justifiant, laquelle de ces deux commandes a produit l'affichage:
`4 packets transmitted, `4 received, `0 packet loss, time `3002 ms
